/**
 * 标签API库
 * @author HalRui
 * @version 1.0.0
 * @description 提供标签相关的业务逻辑处理，包括标签创建、查询、更新、删除、搜索、统计、使用量管理等功能
 * @date 2025年9月27日
 */

const Tags = require('../models/tags-model');
const UserInfos = require('../models/userinfos-model');

/**
 * 创建标签
 * @param {Object} tagData - 标签数据
 * @returns {Promise<Object>} 创建结果
 */
async function createTag(tagData) {
    try {
        const { createdBy } = tagData;
        
        // 验证创建者是否存在（如果提供了创建者ID）
        if (createdBy) {
            const user = await UserInfos.findOne({ userId: createdBy, isDeleted: false });
            if (!user) {
                return {
                    success: false,
                    message: '创建者用户不存在'
                };
            }
        }
        
        const tag = await Tags.createTag(tagData);
        
        return {
            success: true,
            data: tag,
            message: '标签创建成功'
        };
    } catch (error) {
        console.error('创建标签失败:', error);
        return {
            success: false,
            message: error.message || '创建标签失败',
            error: error.message
        };
    }
}

/**
 * 获取标签列表
 * @param {Object} options - 查询选项
 * @returns {Promise<Object>} 标签列表
 */
async function getTagList(options) {
    try {
        const result = await Tags.getTagList(options);
        
        return {
            success: true,
            data: result,
            message: '获取标签列表成功'
        };
    } catch (error) {
        console.error('获取标签列表失败:', error);
        return {
            success: false,
            message: '获取标签列表失败',
            error: error.message
        };
    }
}

/**
 * 获取标签详情
 * @param {number} tagId - 标签ID
 * @returns {Promise<Object>} 标签详情
 */
async function getTagDetail(tagId) {
    try {
        const tag = await Tags.getTagDetail(tagId);
        
        if (!tag) {
            return {
                success: false,
                message: '标签不存在'
            };
        }
        
        // 获取创建者信息
        let creator = null;
        if (tag.createdBy) {
            const user = await UserInfos.findOne({ 
                userId: tag.createdBy, 
                isDeleted: false 
            }).select('userId username avatar');
            
            if (user) {
                creator = {
                    userId: user.userId,
                    username: user.username,
                    avatar: user.avatar
                };
            }
        }
        
        return {
            success: true,
            data: {
                ...tag,
                creator
            },
            message: '获取标签详情成功'
        };
    } catch (error) {
        console.error('获取标签详情失败:', error);
        return {
            success: false,
            message: '获取标签详情失败',
            error: error.message
        };
    }
}

/**
 * 更新标签
 * @param {number} tagId - 标签ID
 * @param {Object} updateData - 更新数据
 * @param {number} userId - 操作用户ID
 * @returns {Promise<Object>} 更新结果
 */
async function updateTag(tagId, updateData, userId) {
    try {
        // 验证用户是否存在
        const user = await UserInfos.findOne({ userId, isDeleted: false });
        if (!user) {
            return {
                success: false,
                message: '用户不存在'
            };
        }
        
        // 获取标签信息
        const existingTag = await Tags.findOne({ tagId, isDeleted: false });
        if (!existingTag) {
            return {
                success: false,
                message: '标签不存在'
            };
        }
        
        // 检查编辑权限
        if (!existingTag.canEdit(userId)) {
            return {
                success: false,
                message: '没有权限编辑此标签'
            };
        }
        
        const tag = await Tags.updateTag(tagId, updateData);
        
        if (!tag) {
            return {
                success: false,
                message: '标签不存在'
            };
        }
        
        return {
            success: true,
            data: tag,
            message: '标签更新成功'
        };
    } catch (error) {
        console.error('更新标签失败:', error);
        return {
            success: false,
            message: error.message || '更新标签失败',
            error: error.message
        };
    }
}

/**
 * 删除标签
 * @param {number} tagId - 标签ID
 * @param {number} userId - 操作用户ID
 * @returns {Promise<Object>} 删除结果
 */
async function deleteTag(tagId, userId) {
    try {
        // 验证用户是否存在
        const user = await UserInfos.findOne({ userId, isDeleted: false });
        if (!user) {
            return {
                success: false,
                message: '用户不存在'
            };
        }
        
        // 获取标签信息
        const tag = await Tags.findOne({ tagId, isDeleted: false });
        if (!tag) {
            return {
                success: false,
                message: '标签不存在'
            };
        }
        
        // 检查删除权限
        if (!tag.canDelete(userId)) {
            return {
                success: false,
                message: '没有权限删除此标签'
            };
        }
        
        const success = await Tags.deleteTag(tagId);
        
        if (!success) {
            return {
                success: false,
                message: '标签删除失败'
            };
        }
        
        return {
            success: true,
            message: '标签删除成功'
        };
    } catch (error) {
        console.error('删除标签失败:', error);
        return {
            success: false,
            message: '删除标签失败',
            error: error.message
        };
    }
}

/**
 * 批量获取标签信息
 * @param {Array} tagIds - 标签ID数组
 * @returns {Promise<Object>} 标签信息
 */
async function getTagsByIds(tagIds) {
    try {
        if (!Array.isArray(tagIds) || tagIds.length === 0) {
            return {
                success: false,
                message: '标签ID列表不能为空'
            };
        }
        
        const tags = await Tags.getTagsByIds(tagIds);
        
        return {
            success: true,
            data: tags,
            message: '获取标签信息成功'
        };
    } catch (error) {
        console.error('批量获取标签信息失败:', error);
        return {
            success: false,
            message: '获取标签信息失败',
            error: error.message
        };
    }
}

/**
 * 获取热门标签
 * @param {Object} options - 查询选项
 * @returns {Promise<Object>} 热门标签列表
 */
async function getPopularTags(options) {
    try {
        const tags = await Tags.getPopularTags(options);
        
        return {
            success: true,
            data: tags,
            message: '获取热门标签成功'
        };
    } catch (error) {
        console.error('获取热门标签失败:', error);
        return {
            success: false,
            message: '获取热门标签失败',
            error: error.message
        };
    }
}

/**
 * 获取标签统计信息
 * @returns {Promise<Object>} 标签统计信息
 */
async function getTagStats() {
    try {
        const stats = await Tags.getTagStats();
        
        return {
            success: true,
            data: stats,
            message: '获取标签统计成功'
        };
    } catch (error) {
        console.error('获取标签统计失败:', error);
        return {
            success: false,
            message: '获取标签统计失败',
            error: error.message
        };
    }
}

/**
 * 搜索标签
 * @param {Object} options - 搜索选项
 * @returns {Promise<Object>} 搜索结果
 */
async function searchTags(options) {
    try {
        const { keyword } = options;
        
        if (!keyword || keyword.trim().length === 0) {
            return {
                success: false,
                message: '搜索关键词不能为空'
            };
        }
        
        const tags = await Tags.searchTags({
            ...options,
            keyword: keyword.trim()
        });
        
        return {
            success: true,
            data: tags,
            message: '搜索标签成功'
        };
    } catch (error) {
        console.error('搜索标签失败:', error);
        return {
            success: false,
            message: '搜索标签失败',
            error: error.message
        };
    }
}

/**
 * 增加标签使用次数
 * @param {number} tagId - 标签ID
 * @param {number} count - 增加数量
 * @returns {Promise<Object>} 更新结果
 */
async function increaseTagUsage(tagId, count = 1) {
    try {
        const success = await Tags.increaseUsageCount(tagId, count);
        
        if (!success) {
            return {
                success: false,
                message: '标签不存在或更新失败'
            };
        }
        
        return {
            success: true,
            message: '标签使用次数更新成功'
        };
    } catch (error) {
        console.error('增加标签使用次数失败:', error);
        return {
            success: false,
            message: '更新标签使用次数失败',
            error: error.message
        };
    }
}

/**
 * 减少标签使用次数
 * @param {number} tagId - 标签ID
 * @param {number} count - 减少数量
 * @returns {Promise<Object>} 更新结果
 */
async function decreaseTagUsage(tagId, count = 1) {
    try {
        const success = await Tags.decreaseUsageCount(tagId, count);
        
        if (!success) {
            return {
                success: false,
                message: '标签不存在或使用次数不足'
            };
        }
        
        return {
            success: true,
            message: '标签使用次数更新成功'
        };
    } catch (error) {
        console.error('减少标签使用次数失败:', error);
        return {
            success: false,
            message: '更新标签使用次数失败',
            error: error.message
        };
    }
}

/**
 * 激活标签
 * @param {number} tagId - 标签ID
 * @param {number} userId - 操作用户ID
 * @returns {Promise<Object>} 激活结果
 */
async function activateTag(tagId, userId) {
    try {
        // 验证用户是否存在
        const user = await UserInfos.findOne({ userId, isDeleted: false });
        if (!user) {
            return {
                success: false,
                message: '用户不存在'
            };
        }
        
        // 获取标签信息
        const tag = await Tags.findOne({ tagId, isDeleted: false });
        if (!tag) {
            return {
                success: false,
                message: '标签不存在'
            };
        }
        
        // 检查编辑权限
        if (!tag.canEdit(userId)) {
            return {
                success: false,
                message: '没有权限操作此标签'
            };
        }
        
        const updatedTag = await tag.activate();
        
        return {
            success: true,
            data: updatedTag,
            message: '标签激活成功'
        };
    } catch (error) {
        console.error('激活标签失败:', error);
        return {
            success: false,
            message: '激活标签失败',
            error: error.message
        };
    }
}

/**
 * 停用标签
 * @param {number} tagId - 标签ID
 * @param {number} userId - 操作用户ID
 * @returns {Promise<Object>} 停用结果
 */
async function deactivateTag(tagId, userId) {
    try {
        // 验证用户是否存在
        const user = await UserInfos.findOne({ userId, isDeleted: false });
        if (!user) {
            return {
                success: false,
                message: '用户不存在'
            };
        }
        
        // 获取标签信息
        const tag = await Tags.findOne({ tagId, isDeleted: false });
        if (!tag) {
            return {
                success: false,
                message: '标签不存在'
            };
        }
        
        // 检查编辑权限
        if (!tag.canEdit(userId)) {
            return {
                success: false,
                message: '没有权限操作此标签'
            };
        }
        
        const updatedTag = await tag.deactivate();
        
        return {
            success: true,
            data: updatedTag,
            message: '标签停用成功'
        };
    } catch (error) {
        console.error('停用标签失败:', error);
        return {
            success: false,
            message: '停用标签失败',
            error: error.message
        };
    }
}

/**
 * 获取标签分类列表
 * @returns {Promise<Object>} 分类列表
 */
async function getTagCategories() {
    try {
        const categories = [
            { value: 'general', label: '通用标签', description: '通用类型的标签' },
            { value: 'genre', label: '类型标签', description: '视频类型分类标签' },
            { value: 'mood', label: '情绪标签', description: '表达情绪的标签' },
            { value: 'topic', label: '主题标签', description: '主题相关的标签' },
            { value: 'style', label: '风格标签', description: '风格类型的标签' },
            { value: 'language', label: '语言标签', description: '语言相关的标签' },
            { value: 'difficulty', label: '难度标签', description: '难度等级的标签' },
            { value: 'duration', label: '时长标签', description: '时长相关的标签' },
            { value: 'quality', label: '质量标签', description: '质量等级的标签' },
            { value: 'custom', label: '自定义标签', description: '用户自定义的标签' }
        ];
        
        return {
            success: true,
            data: categories,
            message: '获取标签分类成功'
        };
    } catch (error) {
        console.error('获取标签分类失败:', error);
        return {
            success: false,
            message: '获取标签分类失败',
            error: error.message
        };
    }
}

module.exports = {
    createTag,
    getTagList,
    getTagDetail,
    updateTag,
    deleteTag,
    getTagsByIds,
    getPopularTags,
    getTagStats,
    searchTags,
    increaseTagUsage,
    decreaseTagUsage,
    activateTag,
    deactivateTag,
    getTagCategories
};